MacFormat 1995 November/macformat-030.iso/Shareware City/Newton/newt-faq-31/newt-faq.txt

Text File | 1995-08-11 | 28.6 KB | 679 lines | [TEXT/R*ch]

Newt-faq.txt  (newt-devenv-faq-31.txt)
8/11/95
S. Weyer

This answers some "frequently asked questions" about Newt, the native Newton
development environment. It recycles, updates and augments information that
is found with the current versions of the Newt package (see "Where do I find
Newt?") and NewtATut book, an interactive Newt Application Tutorial (see
"What other Newt-related packages are available?"). I will revise this faq to
correspond to new versions of Newt, and to clarify old & new user questions.

This FAQ is available in the "usual places -- see "Where can I find Newt?"
as [newt-devenv-faq-31.sit/.hqx/.zip] [CIS: nwtfaq.sit/.zip],
browse my web page: http://www.netaxs.com/~weyer/newton/releases.html
or send me email: [e-mail]

-----

Contents:
- What's new?
- What is "Newt"?
- What is NewtonScript?
- How does Newt compare to NTK (Apple's Newton ToolKit)?
- What are other Newton development alternatives?
- How do I create and run a Newt application?
- Can I create any kind of application using Newt?
- What's the difference between a Newt application and an NTK package?
- What is RUNewt?
- How large an application can I build with Newt?
- How can I transfer a Newt-generated application to another user?
- How do I access Newt-created applications via the Extras drawer?
- Which system prototypes and platform functions are available?
- How do I include graphics and sound resources?
- How do I debug programs with Newt?
- What is Slurpee anyway?
- Are there other development differences between Newt and NTK?
- Who should be a Newt user?
- What's next for Newt?
- Where can I find Newt?
- What other Newt-related packages are available?
- Is there other Newt information available?
- Why should I register?
- How can I register?


-----

What's new?

This has been updated to reflect changes in Newt 3.1 and Slurpee 1.6.
Changes include:

Newt 3.1 (& NewtPack 3.1)
- NewtPack saves "small" packages on pre-1.3 ROM OMP (RUNewt no longer needed)
- NewtPack better progress feedback, faster, creates smaller packages
- NewtPack saves books, apps (auto-close option), autoparts (dispatch-only option)
- Heap button displays current heap/does gc; Eval Controls draggable off screen
- better coordination of Print&Notify behavior between Eval Log, Slurpee, NTK
  if you use Slurpee, you must use Slurpee 1.6 (earlier versions incompatible)
- uses DontAsk patch with standard keyboard (rather than custom keyboard)
- GetNamedResource works directly with Ben Gottlieb's Icon Editor
- cleanup, performance tuning, better heap use, preferences, customization
- faster versions of Newt and NewtPack with native code available to registered users.

Slurpee 1.6
- add Sound? and Refresh? checkboxes
- Inspect? makes view smaller; Slurpee can be dragged off screen
- better coordination of Print&Notify behavior between Newt and Slurpee
  if you use Newt, you must use Newt 3.1 (earlier versions incompatible)
- ctrl-w (or keySettings.closeKey) closes 'viewFrontMost
- much faster kbd entry for replacing ranges with multiple lines
- DUMP! parameter changes; BYE! parameter additions
- several special entrySpec parameters, e.g., translate to Newton unicode
- date types print as dates (e.g., 7/5/95) rather than integers
- fixed localization problem for "real" numbers (, as decimal point in Europe)
- added "Idxs: field to show how many indexes a soup has
- version 1.6N (available to registered Slurpee & Newt users)
  includes support for ADSP and faster serial connections (>9600)
  and has native code to improve transfers by 2-4x

For a complete description, see the change files accompanying each package.

For latest information and versions, check my web page:
  http://www.netaxs.com/~weyer/newton/releases.html


-----

What is "Newt"?

Newt (aka NewtDevEnv) is an environment for developing applications
using NewtonScript and saving as packages directly on your Newton.

Keywords: object-oriented programming, application development environment,
NewtonScript, NTK.

History
Like a chameleon, Newt has evolved to provide different functionality to
different users. The first version of Newt in Oct. '93, inspired by the
Inspector Gadget and Dot2Dot examples from Apple, allowed you to draw
graphics using NewtonScript -- the turtle, its amphibious cousin and name
inspiration, used Logo. You, the learner, could use Newt to explore
mathematics via a turtle microworld, or add NewtonScript methods to emulate
Logo commands and data structures.

With enthusiastic feedback from early users, successive versions allowed you
to create objects based on Newton interface prototypes and save as an
application. Newt's application icon reflects both its original turtle
personality as well as its later, and more dominant, application personality.


-----

What is NewtonScript?

NewtonScript is Newton's built-in, object-oriented (o-o) language.
NewtonScript (NS) shares ancestry with dynamic o-o languages like Smalltalk,
Self, Common Lisp, and ObjectLogo. NewtonScript code is compiled into
bytecodes and interpreted on the Newton.  Although NewtonScript is fast
enough for most applications, a RISC compiler in NTK 1.5 can be used to
dramatically speed up selected NewtonScript methods (though making them much
larger in the process). For more advanced users, familiarity with o-o
concepts and constructs would be useful; for others, Newt should serve as a
brief introduction to these ideas.


-----

How does Newt compare to NTK (Apple's Newton ToolKit)?

Like NTK, Newt uses NewtonScript to define objects and methods.  NTK provides
an excellent (and the only) framework for building large, complex,
industrial-strength applications. However, NTK requires a heavy investment in
terms of software, hardware and training -- making it difficult and expensive
for PC-based developers, students or developer-wanna-bes to find out more
about, and actually do, Newton development. Unlike NTK, you do not need a
Macintosh and $$$ in order to develop Newton applications using Newt. With
Newt, you can develop applications directly on your Newton, or develop them
in a text editor on a Macintosh, PC, Unix workstation.  You copy the text
into NCK, or use use a desktop terminal emulator to transfer the source text
using Slurpee and also to debug.

Newt is shareware and costs $49.50*; NTK 1.5 is currently $295 (BookMaker is an
additional $195). Newt runs on the Newton, though you can also use a PC, Mac, Unix
or other system to edit source and debug; NTK runs only on Macs (68030 and
above) -- though I have seen a beta version of NTK version (1.0) running on
Wndows NT. Support for Newt is currently free; support for NTK costs $250/year
and up. However, as a one person effort, Newt does not have as much documentation
and as many features as NTK. See later questions for further discussion of
Newt's current features and limitations.

*for credit card (via Register), SWREG (on Compuserve), or foreign checks;
$45 for checks in US$

-----

What are other Newton development alternatives?

A Windows version of NTK is still rumored for 1995. "Programming for the
Newton" by McKeehan&Rhodes (ISBN: 0-12-484800-1) is a book that discusses
in-depth a single application example ($30); it comes with a demo version of
NTK (for the Mac), but does not provide a general reference.  A newer book,
"Wireless for the Newton" by McKeehan&Rhodes (ISBN: 0-12-484801-X, is also
available. A version of Basic (NS Basic) runs directly on the Newton and
translates Basic commands into NewtonScript ($99; [e-mail];
http://www.io.com/user/nsbasic/index.html).

For book applications, BookMaker is a pre-processor for NTK for creating
Newton books from text files -- it currently costs $195 and requires NTK.
Paperback for Mac and Windows can be used to create simple (single font)
book-like applications (free).  It is possible to create books
programmatically via Newt, but I would not recommend it.  There are several
application-specific environments, e.g., for creating database forms.  Watch
for Newt's Cape(tm) -- an application that converts HTML -- HyperText Markup
Language) documents (same format as used in WWW (World Wide Web) browsers --
into Newton books and forms.


-----

How do I create and run a Newt application?

You create an application from source text that is stored in a Notepad folder,
e.g., Business. The source text contains object definitions for your
application, and methods to add to Newt itself for use in development.

Once you have built an application in Newt, you run and test it directly in Newt.

From Newt, you can save an application as a package using the NewtPack
plug-in, and then run it from Extras, use package utilities to archive it,
or back it up to the desktop with NCK and then use an ExtractPackage utility.

The "Newt Application Tutorial" book (see "What other Newt-related packages
are available?") demonstrates this basic application development process.


-----

Can I create any kind of application using Newt?

Basically, yes, if you have enough documentation, frame heap, and
perseverance. You may also need to structure your application and adapt NTK
examples somewhat to fit Newt's style and to work around Newton system
limitations. Newt has been tested extensively with 170+ examples, including
versions of most of the DTS (Apple Developer Technical Support) examples,
and other publicly available source examples. A few examples:

- demonstrations of each of the system prototypes (text objects, picture
  buttons, checkboxes, radio buttons, edit fields, gauges, lists, menus,
  expando shells, roll browsers, keyboards, floating views, ...)
  and behaviors (scroll, click, drag, file, route, assist, install, ...)
- an application that modifies rolodex entries in your Name soup
- add panels to the Formulas application
- a number guessing game (Pico Fermi Bagels), including online help book
- transfer data ("soups") to the desktop via serial connection (Slurpee)
- calculators
- soup browsers
- object inspector
- display bitmaps and play sounds -- built-in and in soups
- the game of Life
- Assist Calc (using Intelligent Assistant)
- control your TV via infrared
- questionnaires
- extensions for the QuickFigure spreadsheet
...
see examples.txt for the complete list


-----

What's the difference between a Newt application and an NTK package?

In Newt 3.1, there is no difference (as far as I can tell) between a Newt
and a NTK-generated package. Both reside in a special area known as package
memory. When you open your application, the package uses some dynamic
memory -- also known as frame heap -- for run-time state (the "view");
however, most of the application (the "template") remains in read-only
package memory.

During development, Newt creates an application entirely in dynamic memory,
except for references to built-in (ROM) objects.  During the save process,
Newt 3.1 copies the application into package memory.


-----

What is RUNewt?

In earlier versions of Newt (pre-3.0, and for 3.0 users of pre-1.3 ROM OMP
(Original Message Pads), RUNewt could be used to save Newt applications in a
soup. You could later run these applications with RUNewt, or beam/mail them
to other users. It served as an installer (for Newt applications), launcher
(similar to Extras) and a run-time library (for "platform functions"). With
Newt 3.1, RUNewt is no longer needed/supported since NewtPack works even on
OMP (at least for "small" applications).


-----

How large an application can I build with Newt?

Newt can currently construct most of the "DTS" (Developer Technical Support)
examples that come with NTK and many others (see examples.txt). However,
since applications reside entirely in heap when they are constructed, even
with some creative use of soups, you may eventually see the dreaded "Newton
does not have enough memory to do what you want now. Do you want to Restart?"
(or Exception |evt.ex.outofmem|: (-48216) Ran out of Frames Heap memory).

Hopefully, newer revisions of the Newton system software and hardware will
allocate more space for frame heap and manage it more effectively.  You can
also use package utilities to reduce the number of packages that you have
installed. Newt 3.1 handles heap better and allows larger applications to be
developed and saved as packages.

Practically, the maximum for a regular application (entirely in heap) would be
~50K.  However, if certain objects are obtained from other packages (e.g.,
PlatFunc) or from soups via special techniques (e.g., library packages;
guitune.nwt), packages can be much larger -- over 100K.


-----

How can I transfer a Newt-generated application to another user?

There are two formats for an application:

Source
You can transfer the source from the Notepad by emailing or beaming directly
to another Newton, or by transferring the text to a desktop text file via
Newton Connection Kit or Slurpee.  The other Newton user can then build and
compile the application from the NewtonScript source using Newt.

Package(Binary)
You can beam a Newt-generated package to another Newton using third-party
utilities such as BeamPkg or ScrollEx.  You can do a backup to your desktop
computer using Newon Connection Kit, then use a Mac or Windows
"ExtractPackage" utility to copy the package from the backup file, and then
give this to someone else on a floppy, send as an email attachment, or upload
to an information server/service.


-----

How do I access Newt-created applications via the Extras drawer?

With Newt 3.1, normal ("form") packages appear in Extras automatically when
they are saved and installed.  If you have "autoparts", these do not appear
in Extras but are installed elsewhere as patches or plug-ins. Newt can also
save books (created programmatically); Newt's Cape(tm) can also save books. Newt
will add the ability to create other kinds of packages (font parts, store
parts,...) as these are documented (and there is demand).


-----

Which system prototypes and platform functions are available?

Newt currently includes and documents 59 common system prototypes and
viewclasses (all those documented in NTK). User prototypes are a concise way
to define your own version of a system prototype with your own default and
additional slots and methods, and use it in several places in your application.
You can also include objects that contain other views, e.g., an NTK "linked
layout". Finally, you can use other objects in the ROM or in other
applications (e.g., see Life 1.3 example for borrowing native code methods).

Platform functions are additional functions (like RegisterCardSoup) that are
not built-in to the Newton ROMs, but are normally included as needed by NTK.
All of the platform functions are provided by the PlatFunc plug-in
and can be used by a Newt application.


-----

How do I include graphics and sound resources?

With Slurpee, you can transfer hexadecimal strings that represent bitmap,
PICT, sound and IR remote control code resources -- these can be copied
directly from ResEdit.  After you upload these to a "Bitmaps", "Sound" or
"IRCD" soup, your application can access these at definition or at run-time.
All of the DTS examples involving graphics, sound and IR have been built,
saved and run successfully. However, there are some size constraints,
especially for sounds, due to heap limitations (see "How large an application
can I build with Newt?").  There may be other 3rd party solutions appearing
that will assist in the conversion and transfer of graphic resources.  For
example, the upcoming Newt's Cape Connection Kit (tm) will translate graphics
files and transfer HTML files to the Newton for use in books and forms.


-----

How do I debug programs with Newt?

As you add objects to your application in Newt, you can test objects and
behaviors incrementally. In addition, you can use Newt with NTK's Inspector
or with Slurpee as a remote debugging tool to evaluate and print expressions
interactively via the keyboard, or programmatically Print values and errors.
Newt does not currently support more advanced features such as trace or breakloop.


-----

What is Slurpee anyway?

(Slurpee has been mentioned in several earlier answers).  Although Slurpee is
not required for Newt, it is a very convenient companion tool that can be
used in conjunction with a desktop terminal emulator to:
- transfer source text between Mac or PC and Notepad
- transfer bitmaps and sounds as tab-delimited text into resource soups
- enter text and evaluate expressions with desktop keyboard
- print selections, results and errors to desktop window

(It's $10, or free to registered Newt users; see "What other Newt-related
packages are available?")


-----

Are there other development differences between Newt and NTK?

Newt does not currently provide a layout editor or object browser like NTK
-- instead, objects are organized hierarchically via "pathnames" and
represented textually. Newt does not provide constants as generally as NTK:
it provides development-time constants for "Evaluate" slots, and a limited
form of "DefConst".  Most compile-time functions from NTK can be accessed
in Newt via built-in or user-defined methods.

On the plus side, since development is incremental, you can test the behavior
and layout of an application immediately and more accurately without having
to go through a complete build and upload cycle.  You can also test install
and remove scripts interactively.  It is very easy to add "helpBooks" with
Newt; for NTK, this costs another $195 (for BookMaker) and it is cumbersome.
It may even be easier to build and re-use user prototypes and "linked
layouts" in Newt compared to NTK. Newt's "declare" mechanism is simpler. NTK
has some separate constructs such as "afterScripts" that Newt finesses.

With version 1.5, NTK provides profiling -- this can be useful for
determining bottlenecks in an application.  It also provides for native RISC
compilation -- this can provide significant speedup (though at a much larger
size) for selected methods that do a lot of primitive integer and array
operations.  Although Newt cannot currently compile to native code, it can
use existing native code, e.g., from a "code library" -- see life13.nwt example.


-----

Who should be a Newt user?

Newt is appropriate if you want to learn about NewtonScript programming and
Newton application development, if you would like to build and distribute
small to moderate-sized applications, or if you want to do some portable
prototyping or lack a Macintosh for development. Since Newt complements NTK,
some Newt users are also using or considering NTK. Newt's turtle personality
can provide a portable learning environment for children. Current world-wide
Newt users include PC developers, high school and university students,
professors, financial traders, and my 13-year old daughter.


-----

What's next for Newt?

Newt could evolve in many possible directions:  more examples, more
documentation, non-programmatic application interfaces, support for
application-specific development like database forms, integration with other
Newton applications -- as with most shareware, how Newt will evolve depends
greatly on the feedback and level of support from users.

I will be experimenting with distributing documentation and examples
via the Web, Acrobat & Gopher (in addition to floppies).


-----

Where can I find Newt?

The current version is named newt-devenv-31.sit/.zip/.hqx
[CIS: newt31.sit/.zip] and can be found on:

- internet (also see mirror sites):
  - http://www.netaxs.com/~weyer/newton/releases.html
  - ftp://newton.uiowa.edu/submissions, or /pub/newton/software/.../app/ or /dev
  - ftp://sumex-aim.stanford.edu/info-mac/nwt
  - ftp://ftp.amug.org/pub/newton/newt-slurpee
- newsgroups: comp.binaries.newton
- America Online(AOL): PDA:Software Libraries:Newton (or PDA:New Files)
- Compuserve(CIS): GO NEWTON (DL 8 or 9)
- eWorld: Shareware:Newton
- CD-ROMs: AMUG, Info-Mac,...



-----

What other Newt-related files/packages are available?

- Newt FAQ -- Frequently Asked Questions
  (available with Newt or in this separate text file)
  [newt-devenv-faq-31.sit/.hqx/.zip] [CIS: nwtfaq.sit/.zip]

- NewtATut (Newt Application Tutorial) -- a Newton book version of an
  article entitled "Building Native Newton Applications with Newt" that
  appeared in PIE Developers, Vol. 2.4, July 1994; pp.14-18.  This
  interactive tutorial shows how you can develop a simple application in
  NewtonScript directly on your Newton using Newt.
  [newtatut-book-12.sit/.zip/.hqx] [CIS: apptut.sit/.zip].

  NewtATut may also be available in Adobe's PDF (Portable Document Format)
  for use with Adobe's free Acrobat Reader for Macintosh, Windows, Unix, DOS
  [newtatut-pdf-12.sit/.zip/.hqx] [CIS: apptut.pdf])

- NewtTurt (Newt Turtle Tutorial) -- a book showing you how you can use
  Newt for turtle-style graphics with the NewtDraw plug-in.
  [newtturt-book-12.sit/.zip/.hqx] [CIS: turtut.sit/.zip]

  NewtTurT may also be available in PDF format
  [newtturt-pdf-12.sit/.zip/.hqx] [CIS: turtut.pdf])

- Slurpee -- a utility to transfer data or text between desktop files and
  Newton "soups" (databases); directs keyboard input to fields, and
  prints values and errors to desktop Inspector window; source available
  to registered Newt users.
  [slurpee-16.sit/.zip/.hqx] [CIS: slrp16.sit/.zip]

- Life -- "game of Life" cellular automatic/mathematical simulation;
  includes Newt source [life-12.sit/.zip/.hqx] [CIS: life12.sit/.zip]
  [look for life-13 with native RISC code: 4-40x faster]

- Pico Fermi Bagels -- number guessing game (similar to MasterMind);
  source & NewtPFB tutorial available to registered Newt users
  [pico-fermi-bagels-12.sit/.zip/.hqx] [CIS: pfb12.sit/.zip]

  (soon*: NewtPFB (Newt PFB Tutorial) -- a book like NewtATut showing
  how to create Pico Fermi Bagels.
  [newtpfb-book-11.sit/.zip/.hqx] [CIS: nwtpfb.sit/.zip]  (NewtonBook)
  [newtpfb-pdf-11.sit/.zip/.hqx] [CIS: nwtpfb.pdf]  (PDF))

*Note: this is available currently to registered users, but I will make
it publicly available eventually...

- Newt's Cape -- create Newton books and forms directly from HTML documents
  (HyperText Markup Language is used for WWW (World Wide Web) pages)
  [coming soon]


- Acrobat Reader (2.0) -- an application for navigating, printing,...
  online documents is available free from:
  [Internet]
  ftp://ftp.adobe.com/pub/adobe/Applications/Acrobat/Macintosh, Windows, DOS, UNIX

  [America Online]
  Computing: Application or Electronic Publishing (Macintosh)
  PC Forums:Windows:Text & Word Programs (Windows)

  [Compuserve]
  GO ACROBAT or GO ADOBE, "Download Acrobat Viewer" (Macintosh, Windows, DOS)

  [eWorld]
  Library:MacWeek or Text&Pub (Macintosh)


-----

Is there other Newt information available?

In addition to this public FAQ, and information and examples contain in
Newt-related packages just discussed, there is the article by me that
parallels NewtATut: "Building Native Newton Applications with Newt" appeared
in PIE Developers, Vol. 2.4, July 1994; pp.14-18.  Erica Sadun reviewed
Newt's turtle personality in the same issue. _protoReality 1.3 -- the NANUG
newsletter, available as a Newton book -- features a year-old interview with
me about Newt; _protoReality 2.2 has a "re-interview". _protoReality 1.3 &
1.4 have articles with my daughter on using Newt to draw letters.  Serg Koren
has written Newt reviews:
  http://www.netaxs.com/~archimag/revw.html

You can check my web page which will evolve to contain the latest Newt info:
  http://www.netaxs.com/~weyer/newton/releases.html

And, of course, you can register to receive much more info.


-----

Why should I register?

If you've thought about doing Newton development with NTK, and are unsure if
you still want to spend $295 (BookMaker is an additional $195; reduced from
original bundle price of $795), plus perhaps buy a Mac, Newt is an
inexpensive, compatible way to start learning about NewtonScript, prototype
objects and the Newton system.  Even if you have NTK (or the demo), Newt can
provide new perspectives and examples for (portable) Newton programming.

Newt is fully functional for many applications, but its public documentation
is minimal and includes only a few examples. Registered users can download
files via http or ftp, or receive floppies** (Mac or DOS format) containing
the latest versions of packages, 170+ source examples, and a 80+ page manual
(Acrobat or paper) describing Newt features and NewtonScript syntax and
functions. As a registered user, you also receive notification about upcoming
releases and examples, additional packages and plug-ins, patches for bugs
(though there aren't many), priority in answers to questions, and feedback on
your applications (as time permits). Finally, registration encourages me to
continue development of Newt and other shareware packages, and provides
immediate relief for you of the insidious "shareware procrastination guilt
syndrome".

**Options:

#A. If you have http(web) or ftp access, you can download everything (.sit or
.ZIP). See if you can access "public" files first via
  www.netaxs.com/~weyer/newton/releases.html

#B. Or, I can mail you:
- floppy#1 (current releases, examples, essential plug-ins)
- floppy#2 (manual and tutorials (NewtATut, NewtTurT, NewtPFB) as Acrobat PDF
    (Adobe Portable Document Format) (with bookmarks and cross-reference links);
    plus additional tools/packages
- floppy#3 (optional: if you know you can run, but can't (or would rather not)
    download Acrobat Reader for Macintosh or Windows)

#C. Or, I can mail you
- floppy#1 (current releases, examples, essential plug-ins)
- paper manual.

When you register (assuming you give me an email address), I'll clarify and
confirm these choices with you. If floppies, choose Mac(.sit) or DOS(.zip) format.

see register.txt for more information about these options

Files are in .sit format for Mac floppies, .zip for PC


In addition to the documentation, public releases (described here), and
examples (listed in examples.txt), you will also receive, as they become
available, new (beta) versions, additional docs (monthly Q&A digests), and
additional development plug-ins for
- more constants and error messages
- library templates
- faster package creation



-----

How can I register?

To register, you can
- Save & print Newt's built-in registration form
  or fill-in the form below -- and send a check*
  (cash possible though not encouraged)
- use Compuserve's SWREG service** (Newt's ID#: 3143) [$49.50]
- use a credit card by email registration via the Newton Register**
  application and Kagi shareware registration service (this typically
  requires NewtonMail, though may work with new Newton mail clients);
  there are also versions of Register for Macintosh and Windows -- check
  my home page, or contact me. If you can't find or use the Register
  application directly, you can send me your credit card info, and I
  can create an electronic registration form for you to submit.

*registration fee via check = $45.
**registration fee via Compuserve SWREG, Register, or foreign check = $49.50

Currently registered users can upgrade, and receive floppies (or floppy&paper)
containing with latest releases, examples, and manual for $11 (SWREG, Register)
or $10 (check).

A form is below.  Also see register.txt for more details.

Note: if you provide me your email address, it's easier for me to clarify
options with you, and keep you informed about upcoming releases, examples,
etc.

If you tell me where you obtained Newt, e.g., uiowa, AMUG, sumex, AOL,
Compuserve, eWorld, CD, friend, other, I can ensure that the latest
versions appear there.


----- CUT HERE -----

Registration (newt-faq.txt):
    Newt 3.1

Date: ____________

To:    Steve Weyer
    17 Timber Knoll Drive
    Washington Crossing, PA 18977-1052
    Internet: [e-mail]
    America Online/eWorld/NewtonMail: SteveWeyer
    Compuserve: 74603,2051

From:
    <name>
    <company> (optional)
    <street address>
    <city>, <state>/<province>, <country>, <zip>/<postal code>
    <phone> and/or <fax> (optional)
    <email> (highly recommended)

Examples, Docs (choose A, B, or C):
#A. I'll download everything:     _______
    (tell me path & password)

#B. Floppies (with docs in PDF format)        _______
    Include Acrobat Reader (I don't have it)  _______

#C. Floppy and paper manual       _______

If B or C,  Mac or DOS floppies?  _______


Where I obtained Newt:  ______________

Check for $45 enclosed  _____
(Upgrade: $10)

Comments:   ____________

            ____________